/**
 *                            License
 * THE WORK (AS DEFINED BELOW) IS PROVIDED UNDER THE TERMS OF THIS  
 * CREATIVE COMMONS PUBLIC LICENSE ("CCPL" OR "LICENSE"). 
 * THE WORK IS PROTECTED BY COPYRIGHT AND/OR OTHER APPLICABLE LAW.  
 * ANY USE OF THE WORK OTHER THAN AS AUTHORIZED UNDER THIS LICENSE OR  
 * COPYRIGHT LAW IS PROHIBITED.
 * 
 * BY EXERCISING ANY RIGHTS TO THE WORK PROVIDED HERE, YOU ACCEPT AND  
 * AGREE TO BE BOUND BY THE TERMS OF THIS LICENSE. TO THE EXTENT THIS LICENSE  
 * MAY BE CONSIDERED TO BE A CONTRACT,
 * THE LICENSOR GRANTS YOU THE RIGHTS CONTAINED 
 * HERE IN CONSIDERATION OF YOUR ACCEPTANCE OF SUCH TERMS AND CONDITIONS.
 * 
 */
package com.lineage.server.utils.collections;

import java.util.HashMap;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.concurrent.ConcurrentHashMap;

import javolution.util.FastMap;

/**
 * Class <code>Maps</code> Map集合.
 * 
 * @author jrwz
 * @version 2012-5-9下午05:49:46
 * @see com.lineage.server.utils.collections
 * @since JDK1.7
 */
public final class Maps {

    /**
     * 序列化哈希集合.
     * 
     * @param <K>
     *            - 此映射维护的键的类型
     * @param <V>
     *            - 映射值的类
     */
    public static class SerializableHashMap<K extends Object, V extends Object>
            extends FastMap<K, V> {
        /** 序列版本UID. */
        private static final long serialVersionUID = 1L;

        /**
         * 序列化哈希集合(载入资料).
         */
        public SerializableHashMap() {
            super();
        }

        /**
         * 序列化哈希集合(载入资料).
         * 
         * @param m
         *            - 映射
         */
        public SerializableHashMap(final Map<? extends K, ? extends V> m) {
            super(m);
        }
    }

    /**
     * 创建一个带有指定初始容量、默认加载因子和 concurrencyLevel 的新的空映射.
     * 
     * @param <K>
     *            - 此映射维护的键的类型
     * @param <V>
     *            - 映射值的类
     * @return 用默认初始容量 (16) 和默认加载因子 (0.75) 构造一个新的空映射和（16）concurrencyLevel。
     */
    public static <K, V> ConcurrentHashMap<K, V> newConcurrentHashMap() {
        return new ConcurrentHashMap<K, V>();
    }

    /**
     * 将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射一个值.
     * 
     * @param <K>
     *            - 此映射维护的键的类型
     * @param <V>
     *            - 映射值的类
     * @return 用默认初始容量 (16) 和默认加载因子 (0.75) 构造一个新的空映射和（16）concurrencyLevel。
     */
    public static <K, V> Map<K, V> newConcurrentMap() {
        return new ConcurrentHashMap<K, V>();
    }

    /**
     * 构造一个与给定映射具有相同映射关系的新映射。使用给定映射中映射关系数两倍的容量或 11（选更大的那一个）、默认加载因子和 concurrencyLevel 来创建该映射.
     * 
     * @param <K>
     *            - 此映射维护的键的类型
     * @param <V>
     *            - 映射值的类
     * @param from
     *            - 映射
     * @return 一个新的地图作为地图相同的映射。地图是建立在给定的地图或16（以较高者为准）的能力映射数量的1.5倍，和默认加载因子（0.75）和（16）concurrencyLevel。
     */
    public static <K, V> Map<K, V> newConcurrentMap(final Map<K, V> from) {
        return new ConcurrentHashMap<K, V>(from);
    }

    /**
     * 新哈希集合.
     * 
     * @param <K>
     *            - 此映射维护的键的类型
     * @param <V>
     *            - 映射值的类
     * @return 用默认初始容量 (16) 和默认加载因子 (0.75) 构造一个新的空哈希集合
     * 
     */
    public static <K, V> HashMap<K, V> newHashMap() {
        return new HashMap<K, V>();
    }

    /**
     * 将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射一个值.
     * 
     * @param <K>
     *            - 此映射维护的键的类型
     * @param <V>
     *            - 映射值的类
     * @return FastMap<K, V>()
     */
    public static <K, V> Map<K, V> newMap() {
        return new FastMap<K, V>();
    }

    /**
     * 将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射一个值.
     * 
     * @param <K>
     *            - 此映射维护的键的类型
     * @param <V>
     *            - 映射值的类
     * @param from
     *            - 映射
     * @return FastMap<K, V>(from)
     */
    public static <K, V> Map<K, V> newMap(final Map<K, V> from) {
        return new FastMap<K, V>(from);
    }

    /**
     * 新的序列哈希集合.
     * 
     * @param <K>
     *            - 此映射维护的键的类型
     * @param <V>
     *            - 映射值的类
     * @return 序列哈希集合
     */
    public static <K, V> Map<K, V> newSerializableMap() {
        return new SerializableHashMap<K, V>();
    }

    /**
     * 新的序列哈希集合.
     * 
     * @param <K>
     *            - 此映射维护的键的类型
     * @param <V>
     *            - 映射值的类
     * @param from
     *            - 映射
     * @return 序列哈希集合(from)
     */
    public static <K, V> Map<K, V> newSerializableMap(final Map<K, V> from) {
        return new SerializableHashMap<K, V>(from);
    }

    /**
     * 将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射一个值.
     * 
     * @param <K>
     *            - 此映射维护的键的类型
     * @param <V>
     *            - 映射值的类
     * @return 用默认初始容量 (16) 和默认加载因子 (0.75) 构造一个新的空 WeakHashMap。
     */
    public static <K, V> Map<K, V> newWeakMap() {
        return new WeakHashMap<K, V>();
    }

    /**
     * 将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射一个值.
     * 
     * @param <K>
     *            - 此映射维护的键的类型
     * @param <V>
     *            - 映射值的类
     * @param from
     *            - 映射，其映射关系将存放在此映射中。
     * @return 用与指定的 Map 相同的映射关系构造一个新 WeakHashMap。用默认的加载因子（0.75）创建 WeakHashMap，初始容量足以容纳指定 Map 中的映射关系。
     */
    public static <K, V> Map<K, V> newWeakMap(final Map<K, V> from) {
        return new WeakHashMap<K, V>(from);
    }

    /** Map集合. */
    private Maps() {
    }
}
